/**
 * 用户管理Servlet
 * 用途：处理用户相关的所有后端请求，包括：
 * 1. 用户列表的获取
 * 2. 用户信息的添加
 * 3. 用户信息的修改
 * 4. 用户的删除
 * 5. 用户权限的管理
 */
package com.example.cloudcity.servlet;

import jakarta.servlet.ServletException; // 导入ServletException类，用于处理Servlet异常
import jakarta.servlet.annotation.WebServlet; // 导入WebServlet注解，用于定义Servlet
import jakarta.servlet.http.HttpServlet; // 导入HttpServlet类，作为Servlet的基类
import jakarta.servlet.http.HttpServletRequest; // 导入HttpServletRequest类，用于处理请求
import jakarta.servlet.http.HttpServletResponse; // 导入HttpServletResponse类，用于处理响应

import java.io.IOException; // 导入IOException类，用于处理输入输出异常
import java.sql.*; // 导入SQL相关类
import java.util.*; // 导入集合类
import com.google.gson.Gson; // 导入Gson类，用于处理JSON
import com.google.gson.JsonObject; // 导入JsonObject类，用于处理JSON对象
import java.io.BufferedReader; // 导入BufferedReader类，用于读取请求体
import com.example.cloudcity.utils.LogUtils; // 导入LogUtils类，用于日志记录

public class UserManageServlet extends HttpServlet {
    private static final String DB_URL = "jdbc:mysql://localhost:3306/game"; // 数据库URL
    private static final String USER = "root"; // 数据库用户名
    private static final String PASS = "1234"; // 数据库密码

    // 处理GET请求
    protected void doGet(HttpServletRequest request, HttpServletResponse response) 
            throws ServletException, IOException {
        response.setContentType("application/json;charset=UTF-8"); // 设置响应内容类型为JSON
        response.setHeader("Cache-Control", "no-cache"); // 设置缓存控制
        response.setHeader("Pragma", "no-cache"); // 设置Pragma头

        String action = request.getParameter("action"); // 获取请求参数中的action
        System.out.println("Received action: " + action); // 打印接收到的action
        
        try {
            // 根据action执行不同的操作
            if ("list".equals(action)) {
                listUsers(request, response); // 获取用户列表
            } else if ("get".equals(action)) {
                getUser(request, response); // 获取单个用户信息
            } else {
                response.getWriter().write("{\"error\": \"Unknown action: " + action + "\"}"); // 未知操作
            }
        } catch (Exception e) {
            System.err.println("Error in doGet: " + e.getMessage()); // 打印错误信息
            e.printStackTrace(); // 打印异常堆栈
            response.getWriter().write("{\"error\": \"" + escapeJson(e.getMessage()) + "\"}"); // 返回错误信息
        }
    }

    // 处理POST请求
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) 
            throws ServletException, IOException {
        response.setContentType("application/json;charset=UTF-8"); // 设置响应内容类型为JSON
        
        try {
            // 如果是 JSON 请求
            if (request.getContentType() != null && request.getContentType().contains("application/json")) {
                // 读取 JSON 数据
                StringBuilder buffer = new StringBuilder();
                String line;
                try (BufferedReader reader = request.getReader()) {
                    while ((line = reader.readLine()) != null) {
                        buffer.append(line); // 读取每一行
                    }
                }
                
                // 解析 JSON
                Gson gson = new Gson(); // 创建Gson实例
                JsonObject jsonObject = gson.fromJson(buffer.toString(), JsonObject.class); // 解析JSON对象
                String action = jsonObject.get("action").getAsString(); // 获取action
                
                switch (action) {
                    case "update":
                        updateUser(jsonObject, request, response); // 更新用户信息
                        break;
                    case "add":
                        addUserFromJson(jsonObject, request, response); // 从JSON添加用户
                        break;
                    case "delete":
                        deleteUser(request, response); // 删除用户
                        break;
                    default:
                        response.getWriter().write("{\"success\": false, \"error\": \"Unknown action\"}"); // 未知操作
                }
            } else {
                // 处理普通表单提交
                String action = request.getParameter("action"); // 获取表单中的action
                switch (action) {
                    case "add":
                        addUserFromForm(request, response); // 从表单添加用户
                        break;
                    case "delete":
                        deleteUser(request, response); // 删除用户
                        break;
                    default:
                        response.getWriter().write("{\"success\": false, \"error\": \"Unknown action\"}"); // 未知操作
                }
            }
        } catch (Exception e) {
            System.err.println("Error in doPost: " + e.getMessage()); // 打印错误信息
            e.printStackTrace(); // 打印异常堆栈
            response.getWriter().write("{\"success\": false, \"error\": \"" + escapeJson(e.getMessage()) + "\"}"); // 返回错误信息
        }
    }

    // 获取用户列表
    private void listUsers(HttpServletRequest request, HttpServletResponse response) throws SQLException, IOException {
        Connection conn = null; // 数据库连接
        PreparedStatement stmt = null; // 预编译SQL语句
        ResultSet rs = null; // 结果集
        
        try {
            Class.forName("com.mysql.cj.jdbc.Driver"); // 加载MySQL驱动
            conn = DriverManager.getConnection(DB_URL, USER, PASS); // 获取数据库连接
            
            String sql = "SELECT * FROM users WHERE is_admin = 0"; // 查询普通用户
            stmt = conn.prepareStatement(sql); // 准备SQL语句
            rs = stmt.executeQuery(); // 执行查询
            
            StringBuilder jsonBuilder = new StringBuilder(); // 用于构建JSON响应
            jsonBuilder.append("["); // 开始JSON数组
            
            boolean first = true; // 标记是否为第一个元素
            while (rs.next()) { // 遍历结果集
                if (!first) {
                    jsonBuilder.append(","); // 不是第一个元素，添加逗号
                }
                first = false; // 设置为非第一个元素
                
                long id = rs.getLong("id"); // 获取用户ID
                String username = rs.getString("username"); // 获取用户名
                String password = rs.getString("password"); // 获取密码
                String email = rs.getString("email"); // 获取电子邮件
                String mobile = rs.getString("mobile"); // 获取手机号码
                Timestamp created_at = rs.getTimestamp("created_at"); // 获取创建时间
                Timestamp updated_at = rs.getTimestamp("updated_at"); // 获取更新时间
                
                // 构建用户JSON对象
                jsonBuilder.append("{")
                    .append("\"id\":").append(id).append(",")
                    .append("\"username\":\"").append(escapeJson(username)).append("\",")
                    .append("\"password\":\"").append(escapeJson(password)).append("\",")
                    .append("\"email\":\"").append(escapeJson(email)).append("\",")
                    .append("\"mobile\":\"").append(escapeJson(mobile)).append("\",")
                    .append("\"created_at\":\"").append(created_at != null ? created_at.toString() : "").append("\",")
                    .append("\"updated_at\":\"").append(updated_at != null ? updated_at.toString() : "").append("\",")
                    .append("\"isAdmin\":false,") // 设置用户权限
                    .append("\"userType\":\"普通用户\"") // 设置用户类型
                    .append("}");
                
                System.out.println("Found user: " + username + ", ID: " + id); // 打印找到的用户信息
            }
            
            jsonBuilder.append("]"); // 结束JSON数组
            
            String jsonResponse = jsonBuilder.toString(); // 转换为字符串
            System.out.println("JSON Response: " + jsonResponse); // 打印JSON响应
            
            response.setContentType("application/json;charset=UTF-8"); // 设置响应内容类型为JSON
            response.getWriter().write(jsonResponse); // 返回JSON响应
            
        } catch (Exception e) {
            System.err.println("Error in listUsers: " + e.getMessage()); // 打印错误信息
            e.printStackTrace(); // 打印异常堆栈
            response.getWriter().write("[{\"error\":\"" + escapeJson(e.getMessage()) + "\"}]"); // 返回错误信息
        } finally {
            if (rs != null) rs.close(); // 关闭结果集
            if (stmt != null) stmt.close(); // 关闭PreparedStatement
            if (conn != null) conn.close(); // 关闭数据库连接
        }
    }

    // 从JSON添加用户
    private void addUserFromJson(JsonObject jsonObject, HttpServletRequest request, HttpServletResponse response) 
            throws SQLException, IOException {
        System.out.println("Received data: " + jsonObject.toString()); // 打印接收到的数据
        
        // 获取并验证必填字段
        if (!jsonObject.has("username") || !jsonObject.has("password") || 
            !jsonObject.has("email") || !jsonObject.has("mobile")) {
            response.getWriter().write("{\"success\": false, \"error\": \"缺少必填字段\"}"); // 返回缺少字段的错误信息
            return; // 结束方法
        }
        
        String username = jsonObject.get("username").getAsString(); // 获取用户名
        String password = jsonObject.get("password").getAsString(); // 获取密码
        String email = jsonObject.get("email").getAsString(); // 获取电子邮件
        String mobile = jsonObject.get("mobile").getAsString(); // 获取手机号码
        boolean isAdmin = jsonObject.has("isAdmin") && jsonObject.get("isAdmin").getAsBoolean(); // 获取是否为管理员
        
        // 验证字段不为空
        if (username.trim().isEmpty() || password.trim().isEmpty()) {
            response.getWriter().write("{\"success\": false, \"error\": \"用户名和密码不能为空\"}"); // 返回不能为空的错误信息
            return; // 结束方法
        }
        
        try (Connection conn = DriverManager.getConnection(DB_URL, USER, PASS)) { // 获取数据库连接
            String sql = "INSERT INTO users (username, password, email, mobile, is_admin, created_at, updated_at) " +
                        "VALUES (?, ?, ?, ?, ?, NOW(), NOW())"; // SQL插入语句
            
            try (PreparedStatement stmt = conn.prepareStatement(sql)) { // 准备SQL语句
                stmt.setString(1, username.trim()); // 设置用户名
                stmt.setString(2, password.trim()); // 设置密码
                stmt.setString(3, email.trim()); // 设置电子邮件
                stmt.setString(4, mobile.trim()); // 设置手机号码
                stmt.setBoolean(5, isAdmin); // 设置是否为管理员
                
                int result = stmt.executeUpdate(); // 执行插入操作
                if (result > 0) {
                    LogUtils.logOperation( // 记录操作日志
                        "添加用户",
                        "添加用户: " + username,
                        (String) request.getSession().getAttribute("username"),
                        request,
                        "成功"
                    );
                }
                response.getWriter().write("{\"success\": " + (result > 0) + "}"); // 返回成功信息
            }
        } catch (SQLException e) {
            System.err.println("Error in addUser: " + e.getMessage()); // 打印错误信息
            e.printStackTrace(); // 打印异常堆栈
            response.getWriter().write("{\"success\": false, \"error\": \"" + escapeJson(e.getMessage()) + "\"}"); // 返回错误信息
        }
    }

    // 从表单添加用户
    private void addUserFromForm(HttpServletRequest request, HttpServletResponse response) 
            throws SQLException, IOException {
        String username = request.getParameter("username"); // 获取用户名
        String password = request.getParameter("password"); // 获取密码
        String email = request.getParameter("email"); // 获取电子邮件
        String mobile = request.getParameter("mobile"); // 获取手机号码
        boolean isAdmin = "1".equals(request.getParameter("userType")); // 获取用户类型
        
        try (Connection conn = DriverManager.getConnection(DB_URL, USER, PASS)) { // 获取数据库连接
            String sql = "INSERT INTO users (username, password, email, mobile, is_admin, created_at, updated_at) " +
                        "VALUES (?, ?, ?, ?, ?, NOW(), NOW())"; // SQL插入语句
            
            try (PreparedStatement stmt = conn.prepareStatement(sql)) { // 准备SQL语句
                stmt.setString(1, username); // 设置用户名
                stmt.setString(2, password); // 设置密码
                stmt.setString(3, email); // 设置电子邮件
                stmt.setString(4, mobile); // 设置手机号码
                stmt.setBoolean(5, isAdmin); // 设置是否为管理员
                
                int result = stmt.executeUpdate(); // 执行插入操作
                if (result > 0) {
                    LogUtils.logOperation( // 记录操作日志
                        "添加用户",
                        "添加用户: " + username,
                        (String) request.getSession().getAttribute("username"),
                        request,
                        "成功"
                    );
                }
                response.getWriter().write("{\"success\": " + (result > 0) + "}"); // 返回成功信息
            }
        }
    }

    // 更新用户信息
    private void updateUser(JsonObject data, HttpServletRequest request, HttpServletResponse response) 
            throws SQLException, IOException {
        try {
            long id = data.get("id").getAsLong(); // 获取用户ID
            String username = data.get("username").getAsString(); // 获取用户名
            String email = data.get("email").getAsString(); // 获取电子邮件
            String mobile = data.get("mobile").getAsString(); // 获取手机号码
            boolean isAdmin = data.has("is_admin") ? data.get("is_admin").getAsBoolean() : false; // 获取是否为管理员
            String password = data.has("password") ? data.get("password").getAsString() : null; // 获取密码
            
            System.out.println("Updating user - ID: " + id + ", Username: " + username + ", IsAdmin: " + isAdmin); // 打印更新信息
            
            Connection conn = null; // 数据库连接
            PreparedStatement stmt = null; // 预编译SQL语句
            
            try {
                conn = DriverManager.getConnection(DB_URL, USER, PASS); // 获取数据库连接
                
                // 构建更新 SQL
                StringBuilder sql = new StringBuilder("UPDATE users SET username = ?, email = ?, mobile = ?, is_admin = ?, updated_at = NOW()");
                if (password != null && !password.trim().isEmpty()) {
                    sql.append(", password = ?"); // 如果密码不为空，添加密码更新
                }
                sql.append(" WHERE id = ?"); // 添加条件
                
                stmt = conn.prepareStatement(sql.toString()); // 准备SQL语句
                
                // 设置参数
                int paramIndex = 1;
                stmt.setString(paramIndex++, username); // 设置用户名
                stmt.setString(paramIndex++, email); // 设置电子邮件
                stmt.setString(paramIndex++, mobile); // 设置手机号码
                stmt.setBoolean(paramIndex++, isAdmin); // 设置是否为管理员
                
                if (password != null && !password.trim().isEmpty()) {
                    stmt.setString(paramIndex++, password); // 设置密码
                }
                stmt.setLong(paramIndex, id); // 设置用户ID
                
                // 执行更新
                int result = stmt.executeUpdate(); // 执行更新操作
                if (result > 0) {
                    LogUtils.logOperation( // 记录操作日志
                        "更新用户",
                        "更新用户: " + username,
                        (String) request.getSession().getAttribute("username"),
                        request,
                        "成功"
                    );
                }
                
                System.out.println("Update result: " + result); // 打印更新结果
                
                response.getWriter().write("{\"success\": " + (result > 0) + "}"); // 返回成功信息
            } finally {
                if (stmt != null) stmt.close(); // 关闭PreparedStatement
                if (conn != null) conn.close(); // 关闭数据库连接
            }
        } catch (Exception e) {
            System.err.println("Error updating user: " + e.getMessage()); // 打印错误信息
            e.printStackTrace(); // 打印异常堆栈
            response.getWriter().write("{\"success\": false, \"error\": \"" + escapeJson(e.getMessage()) + "\"}"); // 返回错误信息
        }
    }

    // 删除用户
    private void deleteUser(HttpServletRequest request, HttpServletResponse response) 
            throws SQLException, IOException {
        String idStr = request.getParameter("id"); // 获取用户ID
        
        try {
            long id = Long.parseLong(idStr); // 将ID转换为长整型
            
            try (Connection conn = DriverManager.getConnection(DB_URL, USER, PASS);
                 PreparedStatement stmt = conn.prepareStatement("DELETE FROM users WHERE id = ?")) { // 准备删除SQL语句
                
                stmt.setLong(1, id); // 设置用户ID
                
                int result = stmt.executeUpdate(); // 执行删除操作
                if (result > 0) {
                    LogUtils.logOperation( // 记录操作日志
                        "删除用户",
                        "删除用户ID: " + id,
                        (String) request.getSession().getAttribute("username"),
                        request,
                        "成功"
                    );
                }
                String jsonResponse = "{\"success\":" + (result > 0) + "}"; // 构建JSON响应
                System.out.println("Delete response: " + jsonResponse); // 打印删除响应
                response.getWriter().write(jsonResponse); // 返回JSON响应
            }
        } catch (NumberFormatException e) {
            System.err.println("Invalid ID format: " + idStr); // 打印无效ID格式错误
            response.getWriter().write("{\"success\":false,\"error\":\"Invalid ID format\"}"); // 返回错误信息
        } catch (SQLException e) {
            System.err.println("Database error: " + e.getMessage()); // 打印数据库错误
            response.getWriter().write("{\"success\":false,\"error\":\"Database error\"}"); // 返回错误信息
        }
    }

    // 获取用户信息
    private void getUser(HttpServletRequest request, HttpServletResponse response) 
            throws SQLException, IOException {
        String idStr = request.getParameter("id"); // 获取用户ID
        
        if (idStr == null || idStr.trim().isEmpty()) { // 检查ID参数是否为空
            System.out.println("ID parameter is empty or null");
            response.getWriter().write("{\"error\":\"Invalid ID parameter\"}"); // 返回错误信息
            return; // 结束方法
        }
        
        Connection conn = null; // 数据库连接
        PreparedStatement stmt = null; // 预编译SQL语句
        ResultSet rs = null; // 结果集
        
        try {
            long id = Long.parseLong(idStr.trim()); // 将ID转换为长整型
            
            Class.forName("com.mysql.cj.jdbc.Driver"); // 加载MySQL驱动
            conn = DriverManager.getConnection(DB_URL, USER, PASS); // 获取数据库连接
            
            // 修改 SQL 查询，移除 is_admin 限制
            String sql = "SELECT * FROM users WHERE id = ?"; // 查询用户信息的SQL语句
            stmt = conn.prepareStatement(sql); // 准备SQL语句
            stmt.setLong(1, id); // 设置用户ID
            
            System.out.println("Executing SQL: " + sql + " with ID: " + id); // 打印执行的SQL语句
            rs = stmt.executeQuery(); // 执行查询
            
            if (rs.next()) { // 如果找到用户
                // 构建完整的用户信息
                StringBuilder jsonBuilder = new StringBuilder(); // 用于构建JSON响应
                jsonBuilder.append("{")
                    .append("\"id\":").append(rs.getLong("id")).append(",")
                    .append("\"username\":\"").append(escapeJson(rs.getString("username"))).append("\",")
                    .append("\"password\":\"").append(escapeJson(rs.getString("password"))).append("\",")
                    .append("\"email\":\"").append(escapeJson(rs.getString("email"))).append("\",")
                    .append("\"mobile\":\"").append(escapeJson(rs.getString("mobile"))).append("\",")
                    .append("\"isAdmin\":").append(rs.getInt("is_admin") == 1).append(",") // 设置是否为管理员
                    .append("\"userType\":\"").append(rs.getInt("is_admin") == 1 ? "超级管理员" : "普通用户").append("\"") // 设置用户类型
                    .append("}");
                
                System.out.println("User JSON response: " + jsonBuilder.toString()); // 打印用户JSON响应
                response.getWriter().write(jsonBuilder.toString()); // 返回用户信息
            } else {
                System.out.println("No user found with ID: " + id); // 打印未找到用户信息
                response.getWriter().write("{\"error\":\"User not found\"}"); // 返回错误信息
            }
        } catch (NumberFormatException e) {
            System.out.println("Invalid ID format: " + idStr); // 打印无效ID格式错误
            response.getWriter().write("{\"error\":\"Invalid ID format\"}"); // 返回错误信息
        } catch (Exception e) {
            System.err.println("Error getting user: " + e.getMessage()); // 打印错误信息
            e.printStackTrace(); // 打印异常堆栈
            response.getWriter().write("{\"error\":\"" + escapeJson(e.getMessage()) + "\"}"); // 返回错误信息
        } finally {
            if (rs != null) rs.close(); // 关闭结果集
            if (stmt != null) stmt.close(); // 关闭PreparedStatement
            if (conn != null) conn.close(); // 关闭数据库连接
        }
    }

    // 转义JSON字符串
    private String escapeJson(String input) {
        if (input == null) {
            return ""; // 如果输入为空，返回空字符串
        }
        return input.replace("\\", "\\\\") // 转义反斜杠
                    .replace("\"", "\\\"") // 转义双引号
                    .replace("\b", "\\b") // 转义退格
                    .replace("\f", "\\f") // 转义换页
                    .replace("\n", "\\n") // 转义换行
                    .replace("\r", "\\r") // 转义回车
                    .replace("\t", "\\t"); // 转义制表符
    }
}
